Manual de Java (página 2)

¿Qué son los
mensajes?

Para poder crear
una aplicación se necesita más de un objeto, y
estos objetos no pueden estar aislados unos de otros, para
comunicarse esos objetos se envían mensajes.

Los mensajes son simples llamadas a las funciones o
métodos
del objeto con el se quiere comunicar para decirle que haga
alguna cosa.

¿Qué es la herencia?

La herencia es un mecanismo que permite crear una
clase
basándose en una clase existente, y ésta
tendrá todas las variables y
los métodos de su ‘superclase’, y
además se le podrán añadir otras variables y
métodos propios.

Se llama ‘Superclase’ a la clase de la que
desciende una clase.

Polimorfismo

(Poli=muchos; morfo=Formas), Polimorfismo, es la
cualidad de tener más de una forma. Java, permite que
el código
de sus programas tenga
la posibilidad de ser usados con diferentes tipos de datos u
objetos.

Por ejemplo, supongamos que A y B son dos variables de
tipo entero, entonces, la operación:

C= A+B

Nos devolverá la suma de éstos dos
números, el cuyo resultado será guardado en la
variable C.

Pero supongamos que A y B son del tipo String (es decir,
dos cadenas de caracteres):

String A= "Hola";

String B= "Bienvenidos a la Programación en Java";

String C;

C=A+B;

Al tener esa secuencia de commandos, ya no obtendremos
como resultado la suma de esos dos números, sino la
concatenación de esas dos cadenas. Por tanto, el
resuldao en pantalla, sería el siguiente:

Capítulo II: Introducción al Lenguaje de
Programación Java

Antes de iniciar con instrucciones, reglas y otras
bondades, de Java, es necesario más Bla-bla-bla, vamos a
empezar hablando un poco acerca de la historia de Java. El lector
se preguntará, el por que se le da tanta importancia a
detalles como éste, y es por que, un programador debe
conocer muy bien en el ambiente en el
que se desarrolla. Así como el médico conoce muy
bien el cuerpo humano,
y así puede detectar cuando alguna de las partes de
éste anda fallando, o como el soldado que conoce muy bien
el campo de batalla, para que no vaya ser víctima de una
emboscada por parte del enemigo. De igual manera el programador
en Java, debe conocer hasta el más mínimo detalle
de éste lenguaje de
Programación, y no sólo de java, sino de todos los
lenguajes, en los cuales nos decidamos experimentar y
conocer.

2.1 Historia de Java

Java surgió en 1991 cuando un grupo de
ingenieros de Sun Microsystems trataron de diseñar un
nuevo lenguaje de programación destinado a
electrodomésticos. La reducida potencia de
cálculo
y memoria de los
electrodomésticos llevó a desarrollar un lenguaje
sencillo capaz de generar código de tamaño muy
reducido.

Debido a la existencia de distintos tipos de CPUs y a
los continuos cambios, era importante conseguir una herramienta
independiente del tipo de CPU utilizada.
Desarrollaron un código "neutro" que no dependía
del tipo de electrodoméstico, el cual se ejecutaba sobre
una "máquina hipotética o virtual"

denominada Java Virtual Machine (JVM). Era la JVM quien
interpretaba el código neutro convirtiéndolo a
código particular de la CPU utilizada. Esto
permitía lo que luego se ha convertido en el principal
lema del lenguaje: "Write Once, Run Everywhere". A pesar de los
esfuerzos realizados por suscreadores, ninguna empresa de
electrodomésticos se interesó por el nuevo
lenguaje.

Como lenguaje de programación para computadores,
Java se introdujo a finales de 1995. La clave fue la
incorporación de un intérprete Java en la
versión 2.0 del programa Netscape
Navigator, produciendo una verdadera revolución
en Internet. Java
1.1 apareció a principios de
1997, mejorando

sustancialmente la primera versión del lenguaje.
Java 1.2, más tarde rebautizado como Java 2, nació
a finales de 1998.

Al programar en Java no se parte de cero. Cualquier
aplicación que se desarrolle "cuelga" (o se apoya,
según como se quiera ver) en un gran número de
clases preexistentes. Algunas de ellas las ha podido hacer el
propio usuario, otras pueden ser comerciales, pero siempre hay un
número muy importante de clases que forman parte del
propio lenguaje (el API o Application Programming Interface de
Java). Java incorpora en el propio lenguaje muchos aspectos que
en cualquier otro lenguaje son extensiones propiedad de
empresas de
software o
fabricantes de ordenadores (threads, ejecución remota,
componentes, seguridad, acceso
a bases de datos,
etc.). Por eso muchos expertos opinan que Java es el lenguaje
ideal para aprender la informática moderna, porque incorpora todos
estos conceptos de un modo estándar, mucho más
sencillo y claro que con las citadas extensiones de otros
lenguajes. Esto es consecuencia de haber sido diseñado
más recientemente y por un único equipo.

El principal objetivo del
lenguaje Java es llegar a ser el "nexo universal" que conecte a
los usuarios con la información, esté ésta
situada en el ordenador local, en un servidor de
Web, en una
base de datos
o en cualquier otro lugar.

Java es un lenguaje muy completo (de hecho se
está convirtiendo en un macro-lenguaje: Java 1.0
tenía 12 packages; Java 1.1 tenía 23 y Java 1.2
tiene 59). En cierta forma casi todo depende de casi todo. Por
ello, conviene aprenderlo de modo iterativo: primero una
visión muy general, que se va refinando en sucesivas
iteraciones. Una forma de hacerlo es empezar con un ejemplo
completo en el que ya aparecen algunas de las
características más importantes.

La compañía Sun describe el lenguaje Java
como "simple, orientado a objetos, distribuido, interpretado,
robusto, seguro, de
arquitectura
neutra, portable, de altas prestaciones,
multitarea y dinámico". Además de una serie de
halagos por parte de Sun hacia su propia criatura, el hecho es
que todo ello describe bastante bien el lenguaje Java, aunque en
algunas de esas características el lenguaje sea
todavía bastante mejorable. Algunas de las anteriores
ideas se irán explicando a lo largo de este manual (Tomado
de: "Aprenda Java como si estuviera en Primero").

En éste curso, usaremos una de las versiones
más recientes de Java, como lo es Java 2, y para compilar
los programas, usaremos el compilador: JGrasp 1.8.4 de la
Universidad de
Auburn, el cual puede obtenerse de forma gratuita y sin problemas de
licencia en:
Spider.eng.auburn.edu/user-cgi/grasp/grasp.pl?;dl=download_jgrasp.html

2. Java 2 (antes llamado Java 1.2 o JDK 1.2) es la
   tercera versión importante del lenguaje de
   programación Java.

   No hay cambios conceptuales importantes respecto a
   Java 1.1 (en Java 1.1 sí los hubo respecto a Java
   1.0), sino extensiones y ampliaciones, lo cual hace que a
   muchos efectos –por ejemplo, para esta
   introducción- sea casi lo mismo trabajar con Java
   1.1 o con Java 1.2.

   Los programas desarrollados en Java presentan
   diversas ventajas frente a los desarrollados en otros
   lenguajes como C/C++. La ejecución de programas en
   Java tiene muchas posibilidades: ejecución como
   aplicación independiente (Stand-alone Application),
   ejecución como applet, ejecución como
   servlet, etc. Un applet es una aplicación especial
   que se ejecuta dentro de un navegador o browser (por
   ejemplo Netscape Navigator o Internet
   Explorer) al cargar una página HTML desde
   un servidor Web. El applet se descarga desde el servidor y
   no requiere instalación en el ordenador donde se
   encuentra el browser. Un servlet es una aplicación
   sin interface gráfica que se ejecuta en un servidor
   de Internet. La ejecución como aplicación
   independiente es análoga a los programas
   desarrollados con otros lenguajes.

   Además de incorporar la ejecución
   como Applet, Java permite fácilmente el desarrollo tanto de arquitecturas cliente-servidor como de aplicaciones
   distribuidas, consistentes en crear aplicaciones capaces de
   conectarse a otros ordenadores y ejecutar tareas en varios
   ordenadores simultáneamente, repartiendo por lo
   tanto el
   trabajo. Aunque también otros lenguajes de
   programación permiten crear aplicaciones de este
   tipo, Java incorpora en su propio API estas
   funcionalidades.

   Este puede descargarse, también de forma
   gratuita, desde http://www.java.sum.com

3. Java 2

   Lo primero, es que debe estar instalado primero la
   Máquina virtual de Java,

   Éste curso hemos trabajado con el JDK
   1.5.0_07, el cual se encuentra el hoja web mencionada
   arriba.

   Debe descargar al archivo
   jdk-1_5_0_07-windows-i586-p y luego instalarlo,
   ésta operación puede tardar algunos minutos,
   y si la PC es un poco lenta, le sugiero tener mucha
   paciencia.

   Después de haber instalada a Java2 debe
   instalar a JGrasp ya que éste es el que nos
   servirá como editor de nuestros
   programas.

   

   Después que haya instalado a JGrasp ( si es
   que está haciendo uso de éste programa), debe
   abrir éste programa (JGrasp) y en el menú
   principal, escoger Setting, luego Compiler Setting y luego
   Workspace. Deberá aparecer una ventana, como la que
   se muestra
   a la derecha. En ella debe cerciorarse que en la
   opción de lenguaje, sea Java y que esté
   seleccionada las pestaña que dice:
   Enviromennt.

   Luego seleccionar la carpeta j2sdk 1.5 y dar un
   clic en el botón copy , aparecerá otra
   ventana. Luego debe seleccionar esa copia que acaba de
   hacer (generalmente aparece hasta el final del listado) y
   dar un clic en el botón edit , en la ventana
   que aparecerá, puede cambiar el nombre de la copia.
   Y en la opción llamada V1(%V1) que aparece casi al
   final de la ventana debe instalar la dirección completa en la cual se
   encuentra instalado Java en su máquina (Ejemplo:
   C:Archivos de
   programaJavajdk1.5.0_08bin)

   

   Las demás opciones No deben ser
   modificadas, luego clic en OK. Ahora debe verificar que
   tiene seleccionado el ambiente que recién acaba de
   crear, para ello, seleccione nuevamente el ambiente que ha
   creado (la copia de j2sdk 1.5), luego clic en Apply y clic
   en Ok.

   

   Para desarrollar un Programa en Java, es
   necesario:

   à Editar el
   programa

   à
   Compilarlo

   à
   Ejecutarlo

   à
   Depurarlo

4. ¿Cómo Realizar Un Programa en
   Java?
5. Tipos de Datos

En java, hay que distinguir esencialmente dos grandes
rubros:

1. Tipos de datos
   Orientados a Objetos

   Tipos de Datos Simples

   Tipos	Descripción
   boolean	Representa valores TRUE/FALSE. Esta es una de las grandes diferencias respecto a C
   byte	Representa enteros de 8 bits
   char	Al igual que en C, se utiliza para representar datos de tipo Carácter.
   double	Valores de punto flotante pero con doble precisión
   float	Valores de tipo Real con precisión Simple
   int	Sirve para representar valores de tipo entero
   long	Entero Largo
   short	Entero corto

   Tabla 2.1

   Veamos un poco Acerca del rubro de los datos de tipo
   Entero:

   byte	8 bits	Valores numéricos de –128 a 127
   short	16 bits	Valores numéricos de –32.768 a 32.767
   int	32 bits	Valores numéricos de –2.147.483.648 a 2.147.483.647
   long	64 bits	Valores numéricos sin límite.

   Tabla 2.2

   

   Los tipos de datos Orientados a Objetos
   son:

   à
   Clases

   à
   Interfaces

   à
   Arrays

   De os cuales, hablares en su momento.

   0. Un programa en java, debe tener los siguientes
      elementos:

      *LA ZONA DE INCLUSIÓN: que es similar al
      pre-procesador de C, donde especificamos los
      paquetes que vamos a usar en nuestro programa. Los cuales
      deben ser especificados al inicio del programa, con ayuda
      de la sentencia import y acompañado de un
      punto y coma (;) al final de la
      instrucción.

      Eje:

      Import
      javax.swing.JOptionPane;
      import java.io.*;

      En java, podemos incluir todo el paquete, como
      en el caso de java.io, al agregarle el asterisco; o
      simplemente, especificamos que archivos del paquete que
      queremos usar, como en el primer caso, en el cual estamos
      incluyendo (o mejor dicho importando) el archivo
      JOptionPane, del paquete javax.swing. (El cual nos ayuda
      para poder usar las cajitas de texto
      para mandar información a la pantalla o para
      leerla desde el telado).

      *LAS CLASES: Un Programa en java, debe poseer AL
      MENOS una clase, con la cual se debe proseguir en la
      configuración de nuestro programa.

      Eje:

      class
      PrimerPrograma {
      Como puede verse, una clase se especifica con la palabra
      reservada class.

      Una clase puede ser: Pública o
      Privada.

      De lo cual hablares más adelante, por el
      momento el usuario, debe unicamente especificar una
      clase, únicamente con class por que después
      comprenderá la diferencia y podrá aplicarlo
      a sus programas. Además el nombre de la clase,
      debe iniciar con mayúscula.

      *EL PROGRAMA PRINCIPAL: El cual siempre,
      siempre, siempre se especificará de la siguiente
      manera:

      public static void
      main (String args[]) {
      Lo que está entre los parentesis, indica nada
      más los argumentos que recibe nuestro programa, el
      cual SIEMPRE SERÁ uno del tipo String, el nombre
      de args, puede ser cambiado, pero NUNCA debe omitirse los
      corchetes.

      

      Ahora veamos un pequeño
      Ejemplo:

      Ejemplo 2.1

      Diseñe un programa en Java que muestre en
      pantalla un saludo de Bienvenida al Usuario.

      1 import java.lang.*;
      2 class PrimerPrograma {
      3 public static void
      main (String args[]){
      4
      System.out.println("Hola! Bienvenido a
      Java");
      5 }
      6 }

      Explicación

      En la línea numero Uno, encontramos la
      llamada al paquete, el cual es java.lang (éste
      paquete nos ayuda para usar las funciones matemáticas y otras funciones como
      System.out.println, sin embargo NO es necesario
      especificarlo, ya que Java, por defecto, incluye
      éste paquete en todos los programas que
      creamos).

      Luego encontramos la declaración de la
      clase, la cual es PrimerPrograma, como puede observar la
      primera letra es mayúscula, y como el nombre
      está compuesto por dos palabras (Primer y
      Programa), es por tal razón que cada una de ellas
      tienen su primera letra mayúscula. Otra cosa
      importante es que, el nombre del archivo, ( que tiene
      extención *.java), SIEMPRE se debe llamar igual
      que la clase; es decir que, este código,
      está guardado como: PrimerPrograma.java. Si
      está usando JGrasp, generalmente el coloca el
      nombre y lo unico que tenemos que hacer es dar clic en
      guardar en el commandwindow, pero a veces, con esos
      paradigmas de la programación,
      JGrasp no lo coloca, es por tal razón que debemos
      estar seguros que el archivo ha sido guardado
      con el mismo nombre de la clase. Por que de lo contrario
      lanzará una excepción ( de la cual
      hablaremos más adelante) y NO correrá el
      programa. Posteriormente, encontramos la sentencia
      System.out.println(), el cual nos sirve para mandar
      información a pantalla, la cual será
      mostrada en la consola de DOS, y será más o
      menos así:

      

      Luego encontramos la llave correspondiente al
      main y la llave correspondiente a la clase.

      

      Uso de Variables

      En todas las aplicaciones que realizamos, se
      necesitan entre muchas cosas, valores, datos; que cambien
      a medida se ejecuta el programa.

      Por tal razón, un programa que solo
      muestre en pantalla datos (como el ejemplo 2.1), no es
      muy funcional que se diga. Para ello, es necesario hacer
      uso de las variables que no son más que una
      unidad de almacenamiento, la cual tiene la propiedad
      de cambiar a medida se ejecuta la aplicación ( a
      diferencia de las constantes cuyo valor
      NO cambia).

      Para declarar una variable en Java, se prosigue
      de la siguiente forma:

      tipo identificado=valor;

      Donde:

      Tipo: Es el tipo de dato que
      almacenará, el cual puede ser cualquiera de los
      que se muestran en la tabla 2.1.

      Identificar: que hace referencia al
      nombre de la variable.

      

      Valor: No es necesario, pero Java permite
      inicializar variables, por ejemplo, los contadores,
      acumuladores , etc;

      Ejemplos:

      1 int i;
      2 float
      suma=0;
      3
      double
      saldo;
      4
      String Nombre

      En la línea uno, estamos declarando una
      variable de tipo entero, identificada por i. en la
      línea dos, tenemos una variable del tipo real,
      inicializada a cero, podemos asumir que se trata de un
      acumulador. Luego, se puede hacer notar que saldo,
      está declarada como real de doble
      precisión, y finalmente en la línea 4 se
      encuentre Nombre que es una variable de tipo String, es
      decir; una cadena de caracteres, ya que Java soporta este
      tipo de datos.

      Ejemplo 2.2

      Programa que Muestra el nombre, edad y sueldo de
      una persona.

      class
      DatosPersonales {
      public static void
      main (String args[]) {
      String Nombre="Manuel
      Ortez";
      int edad=20;
      double
      sueldo=500.00;

      System.out.println("Nombre
      del empleado:
      "+Nombre);

      System.out.println("Edad:
      ");//Impresion
      de la leyenda
      edad
      System.out.println(edad);

      System.out.println("Sueldo: "+sueldo);
      }//fin del main

      }//fin de
      la clase

      Explicación

      Como puede notarse, la variable Nombre, es una
      cadena de caracteres, la cual está inicializada, y
      todos los
      valores de una cadena se escriben entre comillas
      dobles. Además note que, en el método System.out.printl, podemos
      hacer varias combinaciones al momento de mandar a la
      impresión. Para el caso, si una ( o más
      cadenas) se van a mandar a impresión
      acompañadas de una (o más variables), estos
      argumentos se unen, mediante el operador ‘+’.
      Sin embargo, esto no es necesario cuando se trata de la
      impresión de una sola variable:

      System.out.println(edad);

      Ejemplo 2.3

      Programa que calcula el area y el
      perímetro de un círculo

      class Circulo
      {
      public
      static void main (String args[])
      {
      double
      radio=2.3;
      double perimetro;
      double area;
      area=Math.PI*radio*radio;
      perimetro=2*Math.PI*radio;
      System.out.println("El area
      es: "+area+" Y
      el perímetro es: "+perimetro);
      }
      }

      Explicación

      Me parece que, en lo único que debemos
      poner atención es en dos
      cosas.

      La primera, es que Math.PI es una constante,
      (3.14159….), la cual, está dentro del
      paquete de java.lang; el cual, como ya lo hemos dicho,
      está incluido, por defecto, en todos nuestros
      programas de manera automática; además que,
      note que la única impresión que se hace,
      enlazamos los parámetros con el operador
      ‘+’.

      System.out.println("El area es:
      "+area+" Y el
      perímetro es:
      "+perimetro);

   1. Elementos de Un programa en
      Java
   2. Operadores, Comentarios y
      Literales.
2. Tipos de datos No orientados o Objetos (Muy parecidos
   a los de C)

En todas las aplicaciones, No solo en Java, sino en
cualquier otro lenguaje de programación, nos ayudan a
enriquecer nuestro código y hacerlo más robusto y
funcional.

Operadores

Un Operador, es un símbolo que le indica
al compilador que realice una determinada operación, ya
sea lógica,
relacional, aritméticas, etc.

Como consecuencia, nacen los diferentes tipos de
operadores que existen. En Java, podemos encontrar los siguientes
tipos:

à Operadores
Aritméticos

à Operadores a
nivel de Bit

à Operadores
Relacionales

à Operadores
Lógicos

Operadores Aritméticos

Estos operadores se utilizan para realizar diferentes
operaciones
aritméticas, por tal razón se utilizan en variables
de tipo numéricas.

Tabla 2.2

Ejemplo 2.4

Programa que usa varios tipo de instrucciones

class Operadores
{
public static void
main (String args[]){
int x=10;
int y=12;
int resultado;
resultado=x+y;
System.out.println("El resultado de
la suma es: "+resultado);
resultado=y-x;
System.out.println("El resultado de
la resta es: "+resultado);
resultado=x/y;
System.out.println("El resultado de
la división es: "+resultado);
x++;
y++;
System.out.println("Ahora x es:
"+x+"y Y es:
"+y);
}
}

Operadores Lógicos

Operadores Relacionales

Comentarios

Un comentario es un mensaje cualquiera, que se
escribe entro del código; pero que no es interpretado por
le compilador, y que ayuda, al programador para futuros
mantenimientos y para comprender, tiempo
después, la secuencia de ejecución del
programa.

Java, posee tres tipos de comentarios:

1. Comienza con /* y termina con */, en él
   podemos escribir una línea o un párrafo completo. Ejemplo:

   /*Ejemplo de un comentario */

   /* También podemos escribir

   Nuestros comentarios

   En varias líneas*/

2. Tradicional:
3. De una sola línea:

Comienzan con una doble barra (//), y se extiende hasta
el final de la línea. Ejemplo:

//Este comentario es válido sólo para una
línea

3. Comentario de Documentación

Comienza con /** y termina con */ son comentario
especiales que javadoc utiliza para generar, documentación acerca del
programa.

Ejemplo:

/** Programa Visor 3.11

San Salvador, El Salvador

Diciembre de 2006*/

Literales

Los literales, son valores fijos que son
legibles, para nosotros los humanos. Generalmente son llamados
constantes.

En java, los literales, pueden ser del tipo real,
entero, cadenas, booleanas y null. Las constantes de tipo
carácter, se encierran entre comillas simples, así:
‘m’, `$`.

Las constantes enteras, son aquellas que no llevan parte
fraccionaria, ni tampoco van entre comillas. Ejemplo: 10,
-1.

Las constantes de tipo flotante, son aquellas que se
componen de una parte entera, un punto decimal, y una parte
fraccionaria: 8.75, 142.639.

Las Literales de tipo cadena, se especifican entre
comillas dobles. Así: "Ejemplo de una cadena";

Además, un literal de tipo String, puede contener
una o más secuencias de escape. Por ejemplo, la secuencia
de escape ‘n’, se utiliza para cambiar de
línea. Así:

"ManuelnOrtez";

Si mandamos a imprimir esa literal, veremos el siguiente
resultado:

Preguntas

1. Mencione, cuáles son los dos grandes rubros de
   tipos de datos en
   Java:________________________________________________________________________________________________________________________________________
2. ¿Cuál es la diferencia entre el tipo
   float y
   double?_________________________________________________________________________________________________________________________________________________________________________________________
3. ¿Para que sirve el tipo Srtring, y el tipo
   double?_________________________________________________________________________________________________________________________________________________________________________________________
4. ¿Un literal y una constante, son lo mismo?,
   ¿si? ¿no? ¿Por
   qué?____________________________________________________________________________________________________________________________________________________________________________________________
5. ¿Cuáles son la diferencias entre los 3
   tipos de comentarios que Java
   soporta?_________________________________________________________________________________________________________________________________________________________________________________________

Ejercicios

1. Escriba un programa que imprima su nombre en
   pantalla
2. Diseñe un programa en Java, que muestre la
   cantidad de gramos que hay en 3 Kg (1Kg=1000g).
3. Diseñe un programa que muestre en pantalla,
   los 5 primeros números y a la par, como se leen cada uno
   de esos números
4. Diseñe una clase en Java, que produzca como
   resultado, la tabla de multiplicar del 7.
5. Se desea crear una clase, que contenga un
   método main, el cual muestre, en un solo método
   de impresión, el nombre de cinco personas, en orden
   alfabético.

Capítulo III: "Entorno Gráfico y
Applets"

Hasta, el momento, no hemos conocido las bondades de
Java, por que, tal parece que, nuestros programas fuesen
compilados en C, ya que corren en la ventana de DOS.

Sin embargo Java permite el uso de ventanas, para leer y
mostrar datos. Así como el uso de aplicaciones web, lo que
se conoce como Applet.

3.1 Uso del paquete javax.swing.*;

Este paquete, contiene dos de los métodos
más importantes, en cuanto a lo que a entorno
gráfico se refiere. Por ejemplo, si queremos mandar
imprimir en pantalla algún mensaje, por medio de una
ventana, la sintaxis es la siguiente:

JOptionPane.showMessageDialog(null,
"Mensaje");

En donde:

Null, es argumento que, SIMPRE lo pondremos en el
método MessageDialog

"Mensaje", es la cadena de caracteres que queremos
imprimir.

Ejemplo 3.1

Veamos este ejemplo que, manda a impresión el
mensaje de Hola

1 import
javax.swing.*;
2
class
Mensaje{
3
public static void
main (String args[]){
4
JOptionPane.showMessageDialog(null,"Hola");
5 }
6 }

El resultado que veremos en la pantalla es el
siguiente:

Ejemplo 3.2

Note, las secuencias de escape que, también se
pueden utilizar en éste método

1 import
javax.swing.*;
2
class
Mensaje1{
3
public static void
main (String args[]){
4
JOptionPane.showMessageDialog(null,"Manual
de JavanUna forma Facil de Aprender a ProgramarnnttDiciembre
de 2006");
5
JOptionPane.showMessageDialog(null, "Creado
por Manuel Ortez");
6 }
7 }

Leer Datos

Para leer los datos, usamos el método
ShowInputDialog, de la forma siguiente:

Var=JOptionPane.showInputDialog("Mensaje");

Donde:

Var: es el nombre de la variable que hace
referencia al valor leído.

Mensaje: Es el mensaje que aparecerá, en
la caja de diálogo.

Pero debemos tener presente que, éste
método devuelve un tipo de dato String, por tal
razón cuando leamos un flotante, double, int, etc, debemos
realizar la conversión.

Ejemplo 3.3

Programa que lee un nombre y luego lo imprime

1 import javax.swing.*;
2 class
Mensaje2{
3
public static void
main (String args[]){
4 String Nombre;
5
Nombre=JOptionPane.showInputDialog("Digite su nombre");
6
JOptionPane.showMessageDialog(null, "Bienvenido "+Nombre);
7
8 }
9 }

Ejemplo 3.4

Se desea Crear una Mini-calculadora, que permita, sumar,
restar y multiplicar dos números ingresados por el
usuario.

1 import javax.swing.*;
2 class
MiniCalcu{
3
public static void
main (String args[]){
4 double n1,
n2, resultado;//Estos son los
numeros
5 String
leer;//variable auxiliar con la cual
leeremos los datos
6
leer=JOptionPane.showInputDialog("Escriba el primer
Número");
7 //Esta es
la forma para hacer el cambio de
cadena a doble
8
n1=Double.parseDouble(leer);
9
leer=JOptionPane.showInputDialog("Escriba el primer
Número");
10
n2=Double.parseDouble(leer);
11
resultado=n1+n2;
12
JOptionPane.showMessageDialog(null, "El
resultado de la suma es:
"+resultado);
13
resultado=n1-n2;
14
JOptionPane.showMessageDialog(null, "El
resultado de la resta es:
"+resultado);
15
resultado=n1*n2;
16
JOptionPane.showMessageDialog(null, "El
resultado de la multiplicación es:
"+resultado);
17
resultado=n1/n2;
18
JOptionPane.showMessageDialog(null, "El
resultado de la división es:
"+resultado);
19 }
20 }

Explicación

El lector, debe notar, la forma en que debe hacer la
conversión de un carácter a un valor diferente.
Para el caso, la línea 8 y 13, después de haber
leído los valores correspondiente, hacemos el cambio
así:

N1=Double.parseDouble(leer);

Double, es la clase que contiene al tipo de dato double,
luego se escribe el método parse, y le pasamos como
argumento, la variable leer, que contiene el número(en
cadena de caracteres), que deseamos convertir a
double.

Si queremos convertir a entero:

N1=Integer.parseInt(leer);

Si lo que queremos es convertirlo a float:

N1=Float.parseFloat(leer);

3.2 Uso de Applet`s

Muchos de los libros y
Manuales de
Java, tratan éste tópico hasta muy avanzados en el
curso. Sin embargo, considero que, es mejor aprender a usar
applets, antes de tratar otros temas como los elementos gráficos, animaciones, etc, que
generalmente, son más conocidas en Internet.

¿Qué es un Applet?

Un Applet, es una mini-aplicación escrita
en Java, y que se ejecuta en un navegador (Netscape, Internet
Explorer, etc), al cargar una página HTML que contiene
información sobre el applet a ejecutar.

Algunas características de las
applets

Las características de las applets se
pueden considerar desde el punto de vista del programador y desde
el del usuario. En este manual lo más importante es el
punto de vista del programador:

à Las
applets no tienen un método main() con el
que comience la ejecución. El papel central de su
ejecución lo asumen otros métodos que se
verán posteriormente.

à Todas las
applets derivan de la clase java.applet.Applet.
La

Figura de la izquierda muestra la jerarquía de
clases de la que deriva la clase Applet. Las
applets deben redefinir ciertos métodos heredados
de Applet que controlan su ejecución:
init(), start(), stop(),
destroy().

à Se heredan otros
muchos métodos de las super-clases de Applet que
tienen que ver con la generación de interfaces gráficas de usuario (AWT). Así, los
métodos gráficos se heredan de Component,
mientras que la capacidad de añadir componentes de
interface de usuario se hereda de Container y de
Panel.

à Las
applets también suelen redefinir ciertos
métodos gráficos: los más importantes son
paint() y update(), heredados de Component y
de Container; y repaint() heredado de
Component.

à Las
applets disponen de métodos relacionados con la
obtención de información, como por ejemplo:
getAppletInfo(), getAppletContext(),
getParameterInfo(), getParameter(),
getCodeBase(), getDocumentBase(), e
isActive().

Métodos que controlan la ejecución de
un applet

Los métodos que se estudian en este Apartado
controlan la ejecución de las applets. De ordinario
el programador tiene que redefinir uno o más de estos
métodos, pero no tiene que preocuparse de
llamarlos:

el browser se encarga de hacerlo.

à Método
init()

Se llama automáticamente al método
init() en cuanto el browser o visualizador carga el
applet. Este método se ocupa de todas las tareas de
inicialización, realizando las funciones del
constructor (al que el browser no llama).

En Netscape Navigator se puede reinicializar un
applet con Shift+Reload.

à Método
start()

El método start() se llama
automáticamente en cuanto el applet se hace
visible, después de haber sido inicializada. Se llama
también cada vez que el applet se hace de nuevo
visible después de haber estado

oculta (por dejar de estar activa esa página del
browser, al cambiar el tamaño de la ventana del browser,
al hacer reload, etc.).

Es habitual crear threads en este método
para aquellas tareas que, por el tiempo que requieren,
dejarían sin recursos al
applet o incluso al browser. Las animaciones y ciertas
tareas a través de Internet son ejemplos de este tipo de
tareas.

à Método
stop()

El método stop() se llama de forma
automática al ocultar el applet (por haber haber
dejado de estar activa la página del browser, por hacer
reload o resize, etc.).

Con objeto de no consumir recursos inútilmente,
en este método se suelen parar las threads que
estén corriendo en el applet, por ejemplo para
mostrar animaciones.

à Método
destroy()

Se llama a este método cuando el applet va
a ser descargada para liberar los recursos que tenga reservados
(excepto la memoria).
De ordinario no es necesario redefinir este método, pues
el que se hereda cumple bien con esta misión.

Métodos para dibujar el applet

Las applets son aplicaciones gráficas que
aparecen en una zona de la ventana del browser. Por ello deben
redefinir los métodos gráficos paint() y
update(). El método paint() se declara en la
forma:

public void paint(Graphics
g)

El objeto gráfico g pertenece a la clase
java.awt.Graphics, que siempre debe ser importada por el
applet. Este objeto define un contexto o estado
gráfico para dibujar (métodos gráficos,
colores, fonts,
etc.) y es creado por el browser.

Todo el trabajo
gráfico del applet (dibujo de
líneas, formas gráficas, texto, etc.) se debe
incluir en el método paint(), porque este
método es llamado cuando el applet se dibuja por
primera vez y también de

forma automática cada vez que el applet se
debe redibujar.

En general, el programador crea el método
paint() pero no lo suele llamar. Para pedir
explícitamente al sistema que
vuelva a dibujar el applet (por ejemplo, por haber
realizado algún cambio) se utiliza el método
repaint(), que es más fácil de usar, pues no
requiere argumentos. El método repaint() se encarga
de llamar a paint() a través de
update().

El método repaint() llama a
update(), que borra todo pintando de nuevo con el color de fondo y
luego llama a paint(). A veces esto produce parpadeo de
pantalla o flickering. Existen dos formas de evitar el
flickering:

1. Redefinir update() de forma que no borre toda
la ventana sino sólo lo necesario.

2. Redefinir paint() y update() para
utilizar doble buffer.

Mediante el objeto de la clase Font asignaremos tipo de
letra, estilo y tamaño. Luego utilizaremos el
método setFont para establecer ese tipo de letra. Para
mostrar esa cadena utilizaremos otros métodos dentro de
paint. En resumen para trabajar con texto, primero le damos las
características, luego las establecemos y por
último lo mostramos.

MOSTRAR TEXTO:

Objeto_gráfico.drawString("mensaje",x,y);

Objeto_grafico.drawChars("mensaje",pos_char,1,x,y);

Cuando mostramos la cadena, la posición donde se
muestra se lo indicamos mediante los valores de x e y, que es el
extremo izquierdo de la línea base de los caracteres. Los
valores que puede tomar el parámetro estilo
son:

Ejemplo 3.5

Diseñe un Applet que Dibuje una leyenda, la cual
el usuario ingresará mediante una caja de
texto.

1 import java.applet.Applet;
2 import java.awt.*;
3 import
javax.swing.*;
4
//declaración de la clase
5 public class
PrimerApplet extends
Applet
6
{
7 String
leyenda;
8 public void
init()
9
{
10 //vamos a leer
11
leyenda=JOptionPane.showInputDialog("Ingrese la Leyenda que Desea
Dibujar:");
12 }
13 public
void paint(Graphics
g)
14
{
15 //llamar a la versión del método paint de
la clase Applet
16
super.paint(g);
17 g.drawString(leyenda,
50,50);
18
//dibujamos el contenido de leyenda,
comenzando en las coordenadas x=50 y Y=50
19 }
20 }

Explicación

Para correr èste código, lo
que debemos hacer es guardar el archivo, una vez que hemos
digitado todas las instrucciones. Luego compilarlo, una vez hecho
esto, procedemos a ejecutarlo, dando un clic sobre el
botón: o en Build/Run as Applet.

En la línea cinco, el lector debe notar una
palabra, nueva extends la cual, le indica al compilador
que, esa clase de deriva de la SuperClase Applet, y que
por tanto éste archivo debe ser tratado como un
Applet.

Luego, realizamos una declaración, de la variable
que vamos a leer, note que, lo hacemos fuera de cualquier
método, esto es, para que ésta variable pueda ser
utilizada por cualquier método sin necesidad de pasarla
como parámetro.

Recuerde, además que, los métodos siempre
serán del tipo public y no devolverán ningún
valor (void), además que paint, recibe como
parámetro, a g (que puede llamarse diferente), y que es
del tipo Graphics. El método drawString, se utiliza para
dibujar una cadena de caracteres, de la cual siempre debemos
especificar, las coordenadas donde iniciará a
dibujar.

Estas coordenadas, de cuentan de la esquina superior
izquierda, hacia la derecha (para x), y hacia abajo (para
y).

Otros métodos útiles son:

g.drawLine(10,10,250,30); Para dibujar una línea,
ancho alto, y coordenadas

g.drawRet(20, 20, 50,50); Para dibujar un
rectángulo, base altura y coordenadas

g.drawOval(5,6,50,50); Para dibujar un övalo, radio
mayor, radio Menor y Coordenadas.

Ejemplo 3.6

Se desea crear un Appletque, dibuje un rectangulo, un
óvalo y una línea, e indique, con una leyenda, el
nombre de la misma.

1 import java.awt.*;
2 import
javax.swing.*;
3
public class DibujosVarios extends JApplet{
4
5 public
void paint(Graphics
g)
6 {
7 super.paint(g);
8 g.drawLine(25,25,100,25);
9
g.drawString("Esta es una
Línea", 30,100);
10 g.drawRect(150,25,50,
60);
11
g.drawString("Este es un
Reactangulo", 150,100);
12
g.drawOval(300,25,40,20);
13 g.drawString("Este es un Ovalo",
300,100);
14
}
15 }

Explicación

Para poder ver, éste archivo, es necesario crear
un archivo HTML, que contenga, el siguiente
código:

<html>

<applet code="DibujosVarios.class" width="500"
height="250" > </applet>

</html>

Recuerde que, éste archivo, lo debe editar con el
bloc de notas y guardarlo con extención *.htm, para ver el
resultado siguiente:

Colores en los Applets

Podemos hacer, que un objeto tenga un color en
específico, o que el fondo del applet, tenga uno u otro
color. La sintaxis es la siguienmte:

à Para objeto:

Nombre_de_objeto.setColor(Color.variable_color);

à Para el fondo:

setBackground(Color.variable_color);

Variable_color, puede ser:

black, white, red, yellow, green, blue,
cyan, orange, gray, darkGrayy lightGray

Ejemplo 3.7

Diseñe un Applet que muestre un mensaje en tres
colores diferentes.

1 import javax.swing.*;
2 import java.awt.*;
3 public
class Dibujos
extends JApplet {
4 public void
init()
5
{
6
setBackground(Color.blue);
7 }
8
9 public void paint (Graphics
g)
10
{
11 super.paint(g);
12
g.setColor(Color.white);
13 g.drawString("Bienvendido",
25,25);
14
g.setColor(Color.cyan);
15 g.drawString("A la programación con Applet",
25,50);
16
g.setColor(Color.yellow);
17 g.drawString("Con Java", 25,75);
18 }
19 }

Preguntas

1. ¿Para que se utiliza el paquete
   javax.swing?_________________________________________________________________________________________________________________________________
2. ¿Cuál es la diferencia entre los
   métodos showInputDialog y el método
   showMessageDialog?___________________________________________________________________________________________________________________________________________________________
3. ¿Qué es un Applet y para que
   sirve?_______________________________________________________________________________________________________________

Ejercicios

1. Diseñe una Aplicación en Java, que
   muestre una frase ingresada por el usuario.
2. Diseñe un Programa que, dada una temperatura
   en Celsius la transforme en Grados Fahrenheit .
3. Se desea Crear una clase, llamada Suma, la cual,
   genere la suma de dos números, ingresados por el
   usuario.
4. Se pide que cree, un Applet, el cual, debe dibujar un
   triangulo Equilátero.
5. Cree un Applet el cual, dibuje un rectángulo,
   y dentro de él, dibuje una cadena de caracteres, la
   cual, puede ser su nombre.
6. Diseñe un Applet en Java, el cual, muestre un
   mensaje en cinco, colores diferentes.
7. Cree un Applet, el cual dibuje un Ovalo, y dentro de
   éste, un Cuadrado.
8. Cree una aplicación web en Java, que le
   permita al usuario, dibujar un Ovalo, pero permitiéndole
   al usuario, poder escoger el tamaño de sus radios.
   Luego, y un poco más abajo, se permita dibujar un
   rectángulo, en el cual, también el usuario, tenga
   la posibilidad de ingresar el tamaño de su base y de su
   altura.